///*******************************************************************************
// * Copyright (c) 2010 Broadcom Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * James Blackburn (Broadcom Corp.) - initial API and implementation
// *******************************************************************************/
//package org.eclipse.ui.tests.concurrency;
//
//import junit.framework.Test;
//import junit.framework.TestCase;
//import junit.framework.TestSuite;
//
//import org.eclipse.core.runtime.IProgressMonitor;
//import org.eclipse.core.runtime.IStatus;
//import org.eclipse.core.runtime.Status;
//import org.eclipse.core.runtime.jobs.ILock;
//import org.eclipse.core.runtime.jobs.ISchedulingRule;
//import org.eclipse.core.runtime.jobs.Job;
//import org.eclipse.core.tests.harness.TestBarrier;
//import org.eclipse.swt.widgets.Display;
//
///**
// * Test for an issue where a lock, held by the UI thread
// * is released while the UI thread is actually performing work
// * having acquired it...
// */
//public class Bug_262032 extends TestCase {
//
// ISchedulingRule identityRule = new ISchedulingRule() {
// public boolean isConflicting(ISchedulingRule rule) {
// return rule == this;
// }
// public boolean contains(ISchedulingRule rule) {
// return rule == this;
// }
// };
//
// public static Test suite() {
// return new TestSuite(Bug_262032.class);
// }
//
// volatile boolean concurrentAccess = false;
//
// /**
// * Threads: UI(+asyncExec), j
// * Locks: lock, IDRule
// *
// * j holds identity Rule
// * ui tries to acquire rule => block and performs asyncMessages
// * asyncExec run and acquire()s lock
// * j then attempts to acquire lock.
// *
// * Deadlock manager believes that UI is waiting for IDrule while holding
// * lock, and Job holds IDRule while attempting lock. Scheduling rules
// * are never released by the Deadlock detector, so the lock is yielded!
// *
// * The expectation is that when threads are 'waiting' they're sat
// * in the ordered lock acquire which can give the locks safely to whoever
// * is deemed to need it. In this case that's not true as the UI
// * is running an async exec.
// *
// * The result is concurrent running in a locked region.
// */
// public void testBug262032() {
// final ILock lock = Job.getJobManager().newLock();
// final TestBarrier tb1 = new TestBarrier(-1);
//
// // Job hols scheduling rule
// Job j = new Job ("Deadlocking normal Job") {
// protected IStatus run(IProgressMonitor monitor) {
// tb1.setStatus(TestBarrier.STATUS_WAIT_FOR_START);
// tb1.waitForStatus(TestBarrier.STATUS_RUNNING);
// lock.acquire();
// //test that we haven't both acquired the lock...
// assertTrue(!concurrentAccess);
// lock.release();
//
// tb1.setStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
// return Status.OK_STATUS;
// };
// };
// j.setRule(identityRule);
// j.schedule();
//
// // Wait for the job with scheduling rule to start
// tb1.waitForStatus(TestBarrier.STATUS_WAIT_FOR_START);
//
// // asyncExec job that wants the lock
// Display.getDefault().asyncExec(new Runnable() {
// public void run() {
// lock.acquire();
// concurrentAccess = true;
// tb1.setStatus(TestBarrier.STATUS_RUNNING);
// // Sleep to test for concurrent access
// try {
// Thread.sleep(1000); } catch (InterruptedException e) {/*don't care*/}
// concurrentAccess = false;
// lock.release();
// }
// });
//
// // This will block, but the UI will continue to service async requests...
// Job.getJobManager().beginRule(identityRule, null);
// Job.getJobManager().endRule(identityRule);
//
// try {
// j.join();
// tb1.waitForStatus(TestBarrier.STATUS_WAIT_FOR_DONE);
// assertEquals(Status.OK_STATUS, j.getResult());
// } catch (InterruptedException e) {fail();}
// }
//
//}